• In Java, the "+" operator is overloaded for String and is typically used to join two Strings together. Operator overloading is a special feature that is only available for the String class and is not supported by Java. Additionally, the "+" operator is implemented internally using the append() methods of the StringBuilder and StringBuffer objects.
• Two Strings are considered equal if they contain exactly the same character in the same order and case. The String class overrides the equals() and hashcode() methods. Consider using the equalsIgnoreCase() method if you want to ignore case when comparing two strings.
• Double quotes are used to enclose strings, such as "abcd," and these representations are known as string literals. I'll explain what a string pool is in the next point.
• In Java, you can create a String from a StringBuffer, a StringBuilder, a byte array, a char array, or another string. Each of these has a constructor provided by the Java String class.

Ways of Creating a String

• By String Literal
• Using new Keyword

String Literal

Syntax to Declare String Literal

<String Type> <string variable name> = "<sequence of string>"; 

e.g

String exam= "DockerTpoint";

The "string constant pool" is checked first by the JVM whenever a string literal is created. A reference to the pooled instance of the string is returned if it already exists. If the string is missing from the pool, a new instance of the string is created and added to the pool.

String exam= "DockerTpoint";
String exam1="DockerTpoint"; //No new instance is created.

Java can use the String Literal to save memory (because no new objects are created if it exists already in the string constant pool).

Example of String Literal in java

Example of String Literal in java

 // Java example of String Literal

public class Main {	
	public static void main(String args[]){  		
		String exam= "DockerTpoint";
		String exam1="DockerTpoint";
		System.out.println(exam);
		System.out.println(exam1);
   } 
}

DockerTpoint 

DockerTpoint 

String by new keyword

With a new operator, the string can be allocated dynamically and declared. When a String is dynamically allocated, a new memory location in the heap is given to it. This string won't be included in the pool of String constants.

String str = new String("Examdeva");

You must "intern" this string if you want to keep it in the constant pool.

String interned = str.intern(); 
// the string will be added to the pool of string constants.

Example of String with new Keyword

Example of String with new keyword in java

public class Main {	
	public static void main(String args[]){  		
        String str = "DockerTpoint"; //String Declared without using new operator
        System.out.println("str = " + str);   
        String str1 = new String("DockerTpoint");  //String Declared using new operator
        System.out.println("str1 = " + str1);
   } 
}

str = DockerTpoint 

str1 = DockerTpoint 

Example of String literals vs String with new Keyword

Example of String literals vs String with new Keyword in java

public class Main {	
    public static void main(String args[]){  		 
    String exam1 = "DockerTpoint"; //string using string literal
    String exam2 = "DockerTpoint";
    String exam3 = new String("DockerTpoint"); // strings using new keyword
    String exam4 = new String("DockerTpoint");
    if(exam1 == exam2){
      System.out.println("String exam1 and exam2 are equal");
    }
    else{
      System.out.println("String exam1 and exam2 are not equal");
    }
    if(exam3 == exam4){
      System.out.println("String exam3 and exam4 are equal");
    }
    else{
      System.out.println("String exam3 and exam4 are not equal");
    }
  } 
}

String exam1 and exam2 are equal 

String exam3 and exam4 are not equal 

StringBuffer in Java

A peer class of String called StringBuffer offers many of the same features as strings. While StringBuffer represents expandable and writable character sequences, the string represents immutable, fixed-length character sequences.

Syntax: Declaration of StringBuffer

StringBuffer str = new StringBuffer("DockerTpoint");

StringBuilder in Java

In Java, a mutable string of characters is represented by the StringBuilder class. The StringBuilder class offers a substitute for the String Class in Java because it generates mutable sequences of characters as opposed to the String Class's immutable ones.

Syntax: Declaration of StringBuilder

StringBuilder sB = new StringBuilder();
sB.append("DockerTpoint");

StringTokenizer in Java

A string can be divided into tokens using Java's StringTokenizer class. Internally, a StringTokenizer object keeps track of where it is in the string that needs to be tokenized. Some operations move this position ahead of the currently processed characters. By extracting a substring from the string that was used to create the StringTokenizer object, a token is returned.

Why string objects are immutable in java?

Java supports immutable string objects.because Java makes use of the string literal concept. Let's say there are five reference variables, all of which refer to the same thing, "Sachin." All reference variables will be impacted if one reference variable alters the value of the object. Because of this, string objects in Java are immutable.